Satisfiability (SAT) Based Bounded Model Checkers

ABSTRACT

Systems and methods that use a solver to find bugs in a target model of a computing system having one or more finite computation paths are provided. The bugs on computation paths of less than a predetermined length are detected by translating the target model to include a state variable AF for one or more states of the target model, wherein AF(S) represents value of the state variable AF at state S; and solving the translated version of the target model that satisfies predetermined constrains.

CROSS-REFERENCE TO RELATED APPLICATIONS

The subject application is a continuation application claiming priority from pending U.S. patent application Ser. No. 12/853,318 filed on Aug. 10, 2010, which in turn claims priority to U.S. patent application Ser. No. 11/285,338, filed 22 Nov. 2005, issued as U.S. Pat. No. 7,835,898 on Nov. 16, 2010. Consideration of the remarks provided below is respectfully requested, which is incorporated herein by reference.

COPYRIGHT & TRADEMARK NOTICES

A portion of the disclosure of this patent document may contain material, which is subject to copyright protection. Certain marks referenced herein may be common law or registered trademarks of the applicant, the assignee or third parties affiliated or unaffiliated with the applicant or the assignee. Use of these marks is for providing an enabling disclosure by way of example and shall not be construed to exclusively limit the scope of the disclosed subject matter to material associated with such marks.

TECHNICAL FIELD

The present invention relates to model checking generally and to satisfiability solvers for model checking in particular.

BACKGROUND

Model checking decides the problem of whether a system satisfies a temporal logic property by exploring the underlying state space. It applies primarily to finite-state models or systems (FSMs) where all the execution paths are infinite. However it can also be conducted on FSMs where some of the execution paths are finite. The state space can be represented in symbolic or explicit form. Symbolic model checking has traditionally employed a Boolean representation of state sets using binary decision diagrams (BDDs) as a way of checking temporal properties, whereas explicit-state model checkers enumerate the set of reachable states of the system.

A path is a maximal sequence of states (S₀, S₁, S₂, . . . ) such that S₀ is an initial state and for each two consecutive states (S_(i−1),S_(i)) there is a transition from state S_(i−1) to state S_(i). The path is infinite if this sequence is infinite. The path is finite if this sequence is finite (i.e., there is no outgoing transition from the last state in this sequence). A bounded path is an initial portion of a path of length n, also known as a “prefix” of a path, and is finite.

Reference is now made to FIG. 1, which illustrates a simple, finite state machine of four states (1-4), where the initial state is 4. In the state machine of FIG. 1, there are transitions (indicated by arrows) back and forth from state 2 to each of the other states 1, 3 and 4. In addition, there is a self-loop labeled 8 at state 1. The transition relation in the state machine in FIG. 1 is total (i.e. there is always a transition from one state to another) and therefore, all the paths are infinite paths. For example, there is a path from state 4 to state 2 to state 4 to state 2, etc. If the path passes through state 1, it can either stay at state 1 (via self-loop 8) or it may return to state 2.

In the article, Symbolic Model Checking without BDDs, by Armin Biere, Alessandro Cimatti, Edmund M. Clarke, Yunshan Zhu in TACAS 1999, the use of Boolean satisfiability (SAT) solvers for linear-time temporal logic (LTL) properties was explored through a technique known as bounded model checking (BMC). As with symbolic model checking, in bounded model checking, the state is encoded in terms of Booleans. A bounded model checker unrolls the model a bounded number of steps for some bound k, and prepares a translation of the model to be checked with a SAT solver for counterexamples over computations of length k.

The translation being checked is defined as the question, is there a bounded path of length k that contains a bug, where a bug is defined as a Boolean predicate over the state of the FSM. If the translation is satisfied (i.e. the answer to the question is Yes), then there is a bug in the model being checked.

A translation A is defined mathematically as:

$\begin{matrix} {A = {{{INIT}\left( S_{0} \right)}\bigwedge\left( {\bigwedge\limits_{i = 1}^{k}{{TR}\left( {S_{i - 1},S_{i}} \right)}} \right)\bigwedge\left( {\bigvee\limits_{i = 0}^{k}{{BAD}\left( S_{i} \right)}} \right)}} & (1) \end{matrix}$

where INIT, TR and BAD are Boolean predicates which check the status of the variables on which they operate. INIT(S₀) returns True if state S₀ is one of the initial states, TR(S_(i−1),S_(i)) returns True if transition (S_(i−1),S_(i)) is a valid transition of the finite state machine and BAD(S_(i)) returns True if state S_(i) is a non-allowed value (i.e. that indicates a bug).

Equation 1 indicates that there is a bounded path of length k such that S₀ is in the initial set INIT(S₀), for each two consecutive states (S_(i−1),S_(i)) there is a transition from state S_(i−1) to state S_(i) and the bounded path passes through a bad state.

The SAT solver then attempts to satisfy condition A (i.e. to find a valid bounded path to at least one of the states that satisfies BAD). A bug is defined as a bad state that is reachable by a computation path. The SAT solver typically also generates a counter-example trace leading to the bug.

In practice, the verification engineer fixes the length parameter k, for example, k=10. The bounded model checker produces translation A and provides it to the SAT solver. If the SAT solver determines that the translation is satisfiable, then a bug is found; otherwise, the result is seen as “k-passed” (i.e. the model does not contain a bug on any bounded path up to length k). Some modern verification tools, such as RuleBase, commercially available from International Business Machines (IBM) Corporation of the USA, also provide automatic modes in which the bound k is automatically increased until a bug is found or the system runs out of resources.

SUMMARY

For purposes of summarizing, certain aspects, advantages, and novel features have been described herein. It is to be understood that not all such advantages may be achieved in accordance with any one particular embodiment. Thus, the disclosed subject matter may be embodied or carried out in a manner that achieves or optimizes one advantage or group of advantages without achieving all advantages as may be taught or suggested herein.

Systems and methods that use a solver to find bugs in a target model of a computing system having one or more finite computation paths are provided. The bugs on computation paths of less than a predetermined length are detected by translating the target model to include a state variable AF for one or more states of the target model, wherein AF(S) represents value of the state variable AF at state S; and solving the translated version of the target model that satisfies predetermined constrains.

In accordance with one or more embodiments, a system comprising one or more logic units is provided. The one or more logic units are configured to perform the functions and operations associated with the above-disclosed methods. In yet another embodiment, a computer program product comprising a computer readable storage medium having a computer readable program is provided. The computer readable program when executed on a computer causes the computer to perform the functions and operations associated with the above-disclosed methods.

One or more of the above-disclosed embodiments in addition to certain alternatives are provided in further detail below with reference to the attached figures. The disclosed subject matter is not, however, limited to any particular embodiment disclosed.

BRIEF DESCRIPTION OF THE DRAWINGS

The disclosed embodiments may be better understood by referring to the figures in the attached drawings, as provided below.

FIG. 1 is a schematic illustration of a simple state machine;

FIG. 2 is an illustration of an exemplary portion of code of a model having a finite path;

FIG. 3 is a schematic illustration of a finite execution path;

FIG. 4 is a block diagram illustration of a SAT solver, constructed and operative in accordance with the present invention;

FIG. 5 is an illustration of exemplary code for an AF flag, forming part of the SAT solver of FIG. 4; and

FIG. 6 is a schematic illustration of a portion of a state machine utilizing the code of FIG. 5.

Features, elements, and aspects that are referenced by the same numerals in different figures represent the same, equivalent, or similar features, elements, or aspects, in accordance with one or more embodiments.

DETAILED DESCRIPTION OF EXAMPLE EMBODIMENTS

In the following detailed description, numerous specific details are set forth in order to provide a thorough understanding of the invention. However, it will be understood by those skilled in the art that the present invention may be practiced without these specific details. In other instances, well-known methods, procedures, and components have not been described in detail so as not to obscure the present invention.

Applicants have noticed that the SAT solver occasionally indicates the lack of a bug when, in fact, there is a bug. This is because Equation 1 asks the question “Is there a bounded path of length k that contains a bug?” and Applicants have noticed that the SAT solver answers the question specifically. That is, the SAT solver will find bounded paths of length k that contain a bug. However, the SAT solver will not identify bugs on paths whose lengths are less than k. This situation may happen when some paths within the model are finite, since, if all paths were infinite, then a bounded path of length less than k may be extended to a bounded path of length k that contains a bug and the SAT solver would then be able to find that extended path.

For example, if there is a bug in a third state of a finite, seven state path, the SAT solver will not find it if the SAT solver was told to find paths longer than 7 states.

Paths of less than length k exist in models which have finite computation paths. A finite computation path may result from a computation ending in a state for which no other state satisfies the transition relation. An exemplary piece of code with finite paths is shown in FIG. 2 and a finite path for this code is shown in FIG. 3, respectively, to which reference is now made.

The code of FIG. 2 has two sections, an ASSIGN section where calculations are made and a TRANS section which may be added by a verification engineer. The ASSIGN section of the code of FIG. 2 may specify that the variable xx has an initial value of 0, that the variable xx may remain unchanged or may increase by 1 in each cycle and that, in the cycle after xx receives the value of 7, it returns to 0.

The second section of FIG. 2 is the TRANS section. In general, the verification engineer may add the TRANS section to change the code for model checking. The TRANS section may be part of a formal verification environment (testbench) using PSL (property specification language) assumptions. Assumptions are a very important convenience of PSL and make environment writing significantly simpler.

For example, after the model checker finds a bug, but before the verification engineer has time to fix the bug, the verification engineer may put the buggy part of the model into a TRANS section, such that the model checker may ignore this part. The verification engineer may similarly cover a complicated section that s/he knows that the model checker will have difficulty checking. Unfortunately, as explained hereinbelow, the TRANS section often creates finite paths which the model checker then cannot properly check.

In the very simple model of FIG. 2, the TRANS operation adds an additional constraint on the xx variable that mandates its transition to 2 once it has become 7. However, the original model required variable xx to return to 0. Clearly no value can satisfy both constraints. Therefore, the path has no continuation and is thus, finite. FIG. 3 graphically presents a valid path in the model described by FIG. 2. In this path, xx is increased from 0 to 7 and there is no arrow between state 7 and state 0.

One simple solution to the finite paths problem may be to provide multiple questions to the SAT solver (i.e. move k along from 0 to a large number by increments of 1), but this is time and resource consuming.

Reference is now made to FIG. 4, which illustrates a bounded model checker 10, constructed and operative in accordance with the present invention. Checker 10 may comprise a translator 12, a SAT solver 14 and a results processor 16. Translator 12 may provide a novel translation, discussed in more detail hereinbelow, for an input model. SAT solver 14 may be any SAT solver, such as MAGE, forming part of RuleBase, commercially available from IBM, or CHAFF, publicly available from Princeton University, New Jersey, USA. SAT solver 14 may take the translation, typically provided in a “Conjunctive Normal Form” and may determine if the translation is satisfiable. SAT solver 14 may generate a counter-example which may list the sequence of states leading to the bad state. Unfortunately, as discussed in more detail hereinbelow, the sequence of states after the bad state may not be valid. Therefore, results processor 16 may review the counter example generated by SAT solver 14 and, in accordance with a one embodiment, may find the cycle in the sequence at which the bad state occurred and may remove from the counter-example all states after it.

In accordance with an embodiment of the present invention, translator 12 may add an additional “Already Failed” state variable AF to the input, where AF(S) indicates the value of state variable AF at state S. State variable AF may have a governing state machine with a “sink” state. FIG. 5, to which reference is now made, provides pseudo-code for state variable AF. FIG. 6, to which reference is also now made, illustrates the state machine operation for state variable AF. In these two figures, the variable BAD (shown without a parameter) indicates that the current state of the model is a bad state (i.e. satisfies the BAD predicate).

The pseudo-code of FIG. 5 indicates that state variable AF begins with a value of 0. AF may change to 1 when the current state of the model is bad (i.e. when BAD=True). In state machine terms (as shown in FIG. 6), when the AF state variable at a state 20 has a value of 0, then there is a transition to a sink state 22. Since sink state 22 has only one output arrow 24, and since arrow 24 leads back to itself, there is no input that will transition it to another state once the state machine reaches this state.

Further, according to the preferred embodiment of the invention, translator 12 may provide a new formula A′ for SAT solver 14 to satisfy. Translation A′ may be defined mathematically as:

$\begin{matrix} {A^{\prime} = {{{INIT}\left( S_{0} \right)}\bigwedge\left( {\bigwedge\limits_{i = 1}^{k}\left( {{{TR}\left( {S_{i - 1},S_{i}} \right)}\bigvee{{AF}\left( S_{i - 1} \right)}} \right)} \right)\bigwedge\left( {\bigvee\limits_{i = 0}^{k}{{BAD}\left( S_{i} \right)}} \right)}} & (2) \end{matrix}$

where INIT, TR and BAD are as defined in the Background and AF is as defined in FIG. 5. In effect, AF may identify those locations in the path which have “already failed” (i.e. for whom a bad state has been found in the path).

In another embodiment of the present invention, the constraints on AF may be added directly to the satisfiability problem. Translator 12 may then translate the result into the satisfiability problem. An exemplary set of constraints may be:

AF(S₀)

Bad(S₀)

AF(S _(i))

(AF(S _(i−1))νBAD(S _(i))) i>0  (3)

In other words, a state S_(i) may be defined as already failed if and only if either it is a bad state or if its previous state S_(i−1) was “Already Failed” and, for an initial state S₀ belonging to INIT(S₀), AF(S₀) may be set to BAD(S₀). It will be appreciated that Equation 3 indicates that all states after a bad state may be defined as already failed.

In an alternative embodiment of the present invention, the constraints may be defined differently. In this alternative embodiment, Equation 3 may become:

AF(S ₀)→Bad(S ₀)

AF(S _(i))→(AF(S _(i−1))νBAD(S _(i))) i>0  (4)

Equation 4 is a relaxed version of Equation 3, an “if” statement rather than an “if and only if” statement.

In a further alternative embodiment, the translation of Equation 2 may be simplified to:

$\begin{matrix} {A^{''} = {{{INIT}\left( S_{0} \right)}\bigwedge\left( {\bigwedge\limits_{i = 1}^{k}\left( {{{TR}\left( {S_{i - 1},S_{i}} \right)}\bigvee{{AF}\left( S_{i - 1} \right)}} \right)} \right)\bigwedge\left( {{AF}\left( S_{k} \right)} \right)}} & (5) \end{matrix}$

It will be appreciated that both constraints (equations 3 and 4) may operate with both translations (equations 2 and 5).

It will further be appreciated that the trace that may be generated from the output of SAT solver 14 (using any of equations 2-5) may contain spurious states after the cycle in which a bug occurred. Such spurious states are extraneous and do not provide further information about the location of a bug. Moreover, such spurious states may violate the constraints of transition relation TR(S_(i),S_(i+1)). Thus, results processor 16 may remove the extraneous bad states from the trace.

In a further alternative embodiment, the translations of the present invention may be used with infinite systems as well. The translations of the present invention may provide better performance (e.g. the SAT solver may find a satisfying assignment faster because when there is a bug in the b-th cycle (for b less than k) the SAT solver does not need to find a valid path for the last (k-b) cycles, and therefore it has better performance.

The disclosed subject matter can take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment comprising both hardware and software elements. One embodiment may be implemented in software, which may comprise firmware, resident software, microcode, and ACMs, without limitation.

Furthermore, one or more embodiments may take the form of a computer program product accessible from a computer-usable or computer readable storage medium providing program code for use by or in connection with a computer or any instruction execution system. For the purposes of this description, a computer-usable or computer readable storage medium can be any apparatus that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.

The medium can be an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device) or a propagation medium. Examples of a computer readable storage medium include a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk and an optical disk. Current examples of optical disks include compact disk—read only memory (CD-ROM), compact disk—read/write (CD-R/W) and DVD.

It should also be understood that the logic code, programs, modules, processes, methods and the order in which the respective steps of each method disclosed here are performed are purely exemplary. Depending on implementation, the steps may be performed in any order or in parallel, unless indicated otherwise in the present disclosure. Further, the logic code is not related, or limited to any particular programming language, and may comprise of one or more modules that execute on one or more processors in a distributed, non-distributed or multiprocessing environment.

Therefore, it should be understood that the disclosed embodiments may be practiced with modification and alteration within the spirit and scope of the appended claims. The description is not intended to be exhaustive or to limit the disclosed subject matter to the precise form disclosed. These and various other adaptations and combinations of the embodiments disclosed are within the scope of the disclosed subject matter and are further defined by the claims and their full scope of equivalents.

While certain features of the invention have been illustrated and described herein, many modifications, substitutions, changes, and equivalents will now occur to those of ordinary skill in the art. It is, therefore, to be understood that the appended claims are intended to cover all such modifications and changes as fall within the true spirit of the invention. 

1. A computer-implemented method for determining whether a computing system satisfies a temporal logic property by exploring the underlying state space, the method comprising: translating a target model for the computing system to include a state variable AF for one or more states of the target model, wherein AF(S) represents value of the state variable AF at state S; and solving the translated version of the target model that satisfies predetermined constrains defined as: AF(S₀)

Bad(S₀) AF(S _(i))

(AF(S _(i−1))νBAD(S _(i))) i>0 where: AF(S_(i)) is the current state S_(i), and BAD(S_(i)) is a Boolean predicate representing the failed states.
 2. The method of claim 1 further comprising: analyzing non-failed states identified as the result of solving the translated version of the target model; and removing from said non-failed states, states succeeding an identified failed state.
 3. A computer-implemented method for determining whether a computing system satisfies a temporal logic property by exploring the underlying state space, the method comprising: translating a target model for the computing system to include a state variable AF for one or more states of the target model, wherein AF(S) represents value of the state variable AF at state S; and solving the translated version of the target model, having one or more finite paths, that satisfies predetermined constrains defined as: AF(S ₀)→Bad(S ₀) AF(S _(i))→(AF(S _(i−1))νBAD(S _(i))) i>0 where: AF(S_(i)) is the current state S_(i), and BAD(S_(i)) is a Boolean predicate representing the failed states.
 4. The method of claim 3 further comprising: analyzing non-failed states identified as the result of solving the translated version of the target model; and removing from said non-failed states, states succeeding an identified failed state.
 5. The method of claim 1 wherein said translating is performed using the following equation: $A^{\prime} = {{{INIT}\left( S_{0} \right)}\bigwedge\left( {\bigwedge\limits_{i = 1}^{k}\left( {{{TR}\left( {S_{i - 1},S_{i}} \right)}\bigvee{{AF}\left( S_{i - 1} \right)}} \right)} \right)\bigwedge\left( {\bigvee\limits_{i = 0}^{k}{{BAD}\left( S_{i} \right)}} \right)}$ where INIT(S₀) is a Boolean predicate which checks if the state S₀ is one of the initial states and TR(S_(i−1),S_(i)) is a transition relation from a previous state S_(i−1) to current state S_(i).
 6. The method of claim 1 wherein said translating is performed using the following equation: $A^{''} = {{{INIT}\left( S_{0} \right)}\bigwedge\left( {\bigwedge\limits_{i = 1}^{k}\left( {{{TR}\left( {S_{i - 1},S_{i}} \right)}\bigvee{{AF}\left( S_{i - 1} \right)}} \right)} \right)\bigwedge\left( {{AF}\left( S_{k} \right)} \right)}$ where INIT(S₀) is a Boolean predicate which checks if the state S₀ is one of the initial states and TR(S_(i−1),S_(i)) is a transition relation from a previous state S_(i−1) to current state S_(i).
 7. The method of claim 3 wherein said translating is performed using at least one of the following equations: $A^{\prime} = {{{INIT}\left( S_{0} \right)}\bigwedge\left( {\bigwedge\limits_{i = 1}^{k}\left( {{{TR}\left( {S_{i - 1},S_{i}} \right)}\bigvee{{AF}\left( S_{i - 1} \right)}} \right)} \right)\bigwedge\left( {\bigvee\limits_{i = 0}^{k}{{BAD}\left( S_{i} \right)}} \right)}$ where INIT(S₀) is a Boolean predicate which checks if the state S₀ is one of the initial states and TR(S_(i−1),S_(i)) is a transition relation from a previous state S_(i−1) to current state S_(i).
 8. The method of claim 3 wherein said translating is performed using the following equation: $A^{''} = {{{INIT}\left( S_{0} \right)}\bigwedge\left( {\bigwedge\limits_{i = 1}^{k}\left( {{{TR}\left( {S_{i - 1},S_{i}} \right)}\bigvee{{AF}\left( S_{i - 1} \right)}} \right)} \right)\bigwedge\left( {{AF}\left( S_{k} \right)} \right)}$ where INIT(S₀) is a Boolean predicate which checks if the state S₀ is one of the initial states and TR(S_(i−1),S_(i)) is a transition relation from a previous state S_(i−1) to current state S_(i).
 9. The method of claim 1 wherein the target model has one or more paths that are finite.
 10. The method of claim 3 wherein all paths in the target model are finite.
 11. A computer implemented system for determining whether a computing system satisfies a temporal logic property by exploring state space of the computing system, the system comprising: a translator for translating a target model for the computing system to include a state variable AF for one or more states of the target model, wherein AF(S) represents value of the state variable AF at state S; and a solver for solving the translated version of the target model that satisfies predetermined constrains defined as either: AF(S₀)

Bad(S₀) AF(S _(i))

(AF(S _(i−1))νBAD(S _(i))) i>0 or AF(S ₀)→Bad(S ₀) AF(S _(i))→(AF(S _(i−1))νBAD(S _(i))) i>0 where: AF(S_(i)) is the current state S_(i), and BAD(S_(i)) is a Boolean predicate representing the failed states.
 12. The system of claim 11 wherein non-failed states identified as the result of solving the translated version of the target model are analyzed to remove from said non-failed states, states succeeding an identified failed state.
 13. The system of claim 11 wherein said translating is performed using the following equation: $A^{\prime} = {{{INIT}\left( S_{0} \right)}\bigwedge\left( {\bigwedge\limits_{i = 1}^{k}\left( {{{TR}\left( {S_{i - 1},S_{i}} \right)}\bigvee{{AF}\left( S_{i - 1} \right)}} \right)} \right)\bigwedge\left( {\bigvee\limits_{i = 0}^{k}{{BAD}\left( S_{i} \right)}} \right)}$ where INIT(S₀) is a Boolean predicate which checks if the state S₀ is one of the initial states and TR(S_(i−1),S_(i)) is a transition relation from a previous state S_(i−1) to current state S_(i).
 14. The system of claim 11 wherein said translating is performed using the following equation: $A^{''} = {{{INIT}\left( S_{0} \right)}\bigwedge\left( {\bigwedge\limits_{i = 1}^{k}\left( {{{TR}\left( {S_{i - 1},S_{i}} \right)}\bigvee{{AF}\left( S_{i - 1} \right)}} \right)} \right)\bigwedge\left( {{AF}\left( S_{k} \right)} \right)}$ where INIT(S₀) is a Boolean predicate which checks if the state S₀ is one of the initial states and TR(S_(i−1),S_(i)) is a transition relation from a previous state S_(i−1) to current state S_(i).
 15. The system of claim 11 wherein the target model has one or more paths that are finite.
 16. Computer program product comprising logic code for determining whether a computing system satisfies a temporal logic property by exploring state space of the computing system, wherein the logic code is stored on a non-transient computer readable storage medium, wherein execution of the logic code on a computer causes the computer to: translate a target model for the computing system to include a state variable AF for one or more states of the target model, wherein AF(S) represents value of the state variable AF at state S; and solve the translated version of the target model that satisfies predetermined constrains defined as either: AF(S₀)

Bad(S₀) AF(S _(i))

(AF(S _(i−1))νBAD(S _(i))) i>0 or AF(S ₀)→Bad(S ₀) AF(S _(i))→(AF(S _(i−1))νBAD(S _(i))) i>0 where: AF(S_(i)) is the current state S_(i), and BAD(S_(i)) is a Boolean predicate representing the failed states.
 17. The computer program product of claim 16 wherein non-failed states identified as the result of solving the translated version of the target model are analyzed to remove from said non-failed states, states succeeding an identified failed state.
 18. The computer program product of claim 16 wherein said translating is performed using the following equation: $A^{\prime} = {{{INIT}\left( S_{0} \right)}\bigwedge\left( {\bigwedge\limits_{i = 1}^{k}\left( {{{TR}\left( {S_{i - 1},S_{i}} \right)}\bigvee{{AF}\left( S_{i - 1} \right)}} \right)} \right)\bigwedge\left( {\bigvee\limits_{i = 0}^{k}{{BAD}\left( S_{i} \right)}} \right)}$ where INIT(S₀) is a Boolean predicate which checks if the state S₀ is one of the initial states and TR(S_(i−1),S_(i)) is a transition relation from a previous state S_(i−1) to current state S_(i).
 19. The computer program product of claim 16 wherein said translating is performed using the following equation: $A^{''} = {{{INIT}\left( S_{0} \right)}\bigwedge\left( {\bigwedge\limits_{i = 1}^{k}\left( {{{TR}\left( {S_{i - 1},S_{i}} \right)}\bigvee{{AF}\left( S_{i - 1} \right)}} \right)} \right)\bigwedge\left( {{AF}\left( S_{k} \right)} \right)}$ where INIT(S₀) is a Boolean predicate which checks if the state S₀ is one of the initial states and TR(S_(i−1),S_(i)) is a transition relation from a previous state S_(i−1) to current state S_(i).
 20. The computer program product of claim 16 wherein the target model has one or more paths that are finite. 